home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / eiffel / smalleif.97 / se.t / SmallEiffel / bin_c / pretty10.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-02  |  29.4 KB  |  1,345 lines
  1. /* ANSI C code generated by SmallEiffel. */
  2. /*
  3. -- SmallEiffel  -- Release (- 0.97)    --      FRANCE
  4. -- Copyright (C), 1994 - Dominique COLNET and Suzanne COLLIN 
  5. -- University Henri Poincare' - Nancy 1 - email colnet@loria.fr 
  6. -- CRIN (Centre de Recherche en Informatique de Nancy)
  7. -- FRANCE 
  8. */
  9. #include "pretty.h"
  10. void rT62pretty_print(T62 *C){
  11. /*IF*/if (((int)(C)->_tag)) {
  12. rT259put_string((T259*)oRBC27fmt,((T157*)(C)->_tag)->_to_string);
  13. rT259put_string((T259*)oRBC27fmt,(T0 *)ms488);
  14. }
  15. /*FI*//*IF*/if (((int)(C)->_expression)) {
  16. XrT66pretty_print((C)->_expression);
  17. /*IF*/if (((T259*)oRBC27fmt)->_semi_colon_flag) {
  18. rT259put_string((T259*)oRBC27fmt,(T0 *)ms489);
  19. }
  20. /*FI*/}
  21. /*FI*//*IF*/if (((int)(C)->_comment)) {
  22. rT57pretty_print((T57*)(C)->_comment);
  23. }
  24. /*FI*/}
  25. void rT62copy(T62 *C,T0 * a1){
  26. /*IF*//*AF*//*AE*/
  27. memcpy(C,a1,s[C->id]);
  28. /*FI*/}
  29. void rT62make(T62 *C,T0 * a1,T0 * a2,T0 * a3){
  30. C->_tag=a1;
  31. C->_expression=a2;
  32. C->_comment=a3;
  33. }
  34. void rT138pretty_print(T138 *C){
  35. int _i=0;
  36. rT259level_incr((T259*)oRBC27fmt);
  37. rT259indent((T259*)oRBC27fmt);
  38. /*IF*/if (((int)(C)->_header_comment)) {
  39. rT57pretty_print((T57*)(C)->_header_comment);
  40. }
  41. /*FI*//*IF*/if (((int)(C)->_list)) {
  42. _i=1;
  43. while (!((_i)>(((T215*)(C)->_list)->_upper))) {
  44. /*(IRF3*/(((T259*)oRBC27fmt)->_semi_colon_flag)=(1);
  45. /*)*/rT259indent((T259*)oRBC27fmt);
  46. XrT174pretty_print(rT215item((T215*)(C)->_list,_i));
  47. _i=(_i)+(1);
  48. }
  49. }
  50. /*FI*/rT259level_decr((T259*)oRBC27fmt);
  51. }
  52. void rT138copy(T138 *C,T0 * a1){
  53. /*IF*//*AF*//*AE*/
  54. memcpy(C,a1,s[C->id]);
  55. /*FI*/}
  56. void rT138make(T138 *C,T0 * a1,T0* a2){
  57. C->_header_comment=a1;
  58. C->_list=a2;
  59. }
  60. void rT256clear_all(T256 *C){
  61. T0 * _value=NULL;
  62. rT256set_all_with(C,_value);
  63. }
  64. int rT256count(T256 *C){
  65. int R=0;
  66. R=(((C)->_upper)-((C)->_lower))+(1);
  67. return R;
  68. }
  69. void rT256set_all_with(T256 *C,T0 * a1){
  70. int _i=0;
  71. _i=(C)->_upper;
  72. while (!((_i)<((C)->_lower))) {
  73. rT256put(C,a1,_i);
  74. _i=(_i)-(1);
  75. }
  76. }
  77. void rT256resize(T256 *C,int a1,int a2){
  78. int _up=0;
  79. int _i=0;
  80. T0* _other=NULL;
  81. {T256 *n=((T256*)new(256));
  82. rT256make(n,a1,a2);
  83. _other=(T0 *)n;}
  84. _i=rT2max((C)->_lower,((T256*)_other)->_lower);
  85. _up=rT2min((C)->_upper,((T256*)_other)->_upper);
  86. while (!((_i)>(_up))) {
  87. rT256put((T256*)_other,rT256item(C,_i),_i);
  88. _i=(_i)+(1);
  89. }
  90. /*IF*/{/*AT*/free(C->_storage);
  91. }
  92. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  93. }
  94. T0 * rT256item(T256 *C,int a1){
  95. T0 * R=NULL;
  96. R=(C->_storage)[a1-(C->_lower)];
  97. return R;
  98. }
  99. void rT256add_last(T256 *C,T0 * a1){
  100. /*IF*/if (((C)->_capacity)<((rT256count(C))+(1))) {
  101. C->_capacity=((C)->_capacity)+(16);
  102. /*IF*/if (((C)->_capacity)==(16)) {
  103. C->_storage=malloc(16*sizeof(*(C->_storage)));
  104. }
  105. else {
  106. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  107. }
  108. /*FI*/}
  109. /*FI*/C->_upper=((C)->_upper)+(1);
  110. rT256put(C,a1,(C)->_upper);
  111. }
  112. void rT256put(T256 *C,T0 * a1,int a2){
  113. (C->_storage)[a2-(C->_lower)]=a1;
  114. }
  115. void rT256copy(T256 *C,T0* a1){
  116. int _i=0;
  117. C->_upper=((C)->_lower)-(1);
  118. /*IF*/if (((C)->_capacity)==(0)) {
  119. rT256make(C,((T256*)a1)->_lower,((T256*)a1)->_upper);
  120. }
  121. else {
  122. rT256resize(C,((T256*)a1)->_lower,((T256*)a1)->_upper);
  123. }
  124. /*FI*/_i=(C)->_lower;
  125. while (!((_i)>((C)->_upper))) {
  126. rT256put(C,rT256item((T256*)a1,_i),_i);
  127. _i=(_i)+(1);
  128. }
  129. }
  130. void rT256make(T256 *C,int a1,int a2){
  131. /*IF*/{/*AT*/free(C->_storage);
  132. }
  133. /*FI*/C->_lower=a1;
  134. C->_upper=a2;
  135. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  136. C->_storage=NULL;
  137. /*IF*/if (((C)->_capacity)>(0)) {
  138. C->_capacity=((C)->_capacity)+(16);
  139. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  140. rT256clear_all(C);
  141. }
  142. /*FI*/}
  143. void rT232clear_all(T232 *C){
  144. T0 * _value=NULL;
  145. rT232set_all_with(C,_value);
  146. }
  147. int rT232count(T232 *C){
  148. int R=0;
  149. R=(((C)->_upper)-((C)->_lower))+(1);
  150. return R;
  151. }
  152. void rT232set_all_with(T232 *C,T0 * a1){
  153. int _i=0;
  154. _i=(C)->_upper;
  155. while (!((_i)<((C)->_lower))) {
  156. rT232put(C,a1,_i);
  157. _i=(_i)-(1);
  158. }
  159. }
  160. void rT232resize(T232 *C,int a1,int a2){
  161. int _up=0;
  162. int _i=0;
  163. T0* _other=NULL;
  164. {T232 *n=((T232*)new(232));
  165. rT232make(n,a1,a2);
  166. _other=(T0 *)n;}
  167. _i=rT2max((C)->_lower,((T232*)_other)->_lower);
  168. _up=rT2min((C)->_upper,((T232*)_other)->_upper);
  169. while (!((_i)>(_up))) {
  170. rT232put((T232*)_other,rT232item(C,_i),_i);
  171. _i=(_i)+(1);
  172. }
  173. /*IF*/{/*AT*/free(C->_storage);
  174. }
  175. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  176. }
  177. T0 * rT232item(T232 *C,int a1){
  178. T0 * R=NULL;
  179. R=(C->_storage)[a1-(C->_lower)];
  180. return R;
  181. }
  182. void rT232add_last(T232 *C,T0 * a1){
  183. /*IF*/if (((C)->_capacity)<((rT232count(C))+(1))) {
  184. C->_capacity=((C)->_capacity)+(16);
  185. /*IF*/if (((C)->_capacity)==(16)) {
  186. C->_storage=malloc(16*sizeof(*(C->_storage)));
  187. }
  188. else {
  189. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  190. }
  191. /*FI*/}
  192. /*FI*/C->_upper=((C)->_upper)+(1);
  193. rT232put(C,a1,(C)->_upper);
  194. }
  195. void rT232put(T232 *C,T0 * a1,int a2){
  196. (C->_storage)[a2-(C->_lower)]=a1;
  197. }
  198. void rT232copy(T232 *C,T0* a1){
  199. int _i=0;
  200. C->_upper=((C)->_lower)-(1);
  201. /*IF*/if (((C)->_capacity)==(0)) {
  202. rT232make(C,((T232*)a1)->_lower,((T232*)a1)->_upper);
  203. }
  204. else {
  205. rT232resize(C,((T232*)a1)->_lower,((T232*)a1)->_upper);
  206. }
  207. /*FI*/_i=(C)->_lower;
  208. while (!((_i)>((C)->_upper))) {
  209. rT232put(C,rT232item((T232*)a1,_i),_i);
  210. _i=(_i)+(1);
  211. }
  212. }
  213. void rT232make(T232 *C,int a1,int a2){
  214. /*IF*/{/*AT*/free(C->_storage);
  215. }
  216. /*FI*/C->_lower=a1;
  217. C->_upper=a2;
  218. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  219. C->_storage=NULL;
  220. /*IF*/if (((C)->_capacity)>(0)) {
  221. C->_capacity=((C)->_capacity)+(16);
  222. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  223. rT232clear_all(C);
  224. }
  225. /*FI*/}
  226. void rT230clear_all(T230 *C){
  227. T0 * _value=NULL;
  228. rT230set_all_with(C,_value);
  229. }
  230. int rT230count(T230 *C){
  231. int R=0;
  232. R=(((C)->_upper)-((C)->_lower))+(1);
  233. return R;
  234. }
  235. void rT230set_all_with(T230 *C,T0 * a1){
  236. int _i=0;
  237. _i=(C)->_upper;
  238. while (!((_i)<((C)->_lower))) {
  239. rT230put(C,a1,_i);
  240. _i=(_i)-(1);
  241. }
  242. }
  243. void rT230resize(T230 *C,int a1,int a2){
  244. int _up=0;
  245. int _i=0;
  246. T0* _other=NULL;
  247. {T230 *n=((T230*)new(230));
  248. rT230make(n,a1,a2);
  249. _other=(T0 *)n;}
  250. _i=rT2max((C)->_lower,((T230*)_other)->_lower);
  251. _up=rT2min((C)->_upper,((T230*)_other)->_upper);
  252. while (!((_i)>(_up))) {
  253. rT230put((T230*)_other,rT230item(C,_i),_i);
  254. _i=(_i)+(1);
  255. }
  256. /*IF*/{/*AT*/free(C->_storage);
  257. }
  258. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  259. }
  260. T0 * rT230item(T230 *C,int a1){
  261. T0 * R=NULL;
  262. R=(C->_storage)[a1-(C->_lower)];
  263. return R;
  264. }
  265. void rT230add_last(T230 *C,T0 * a1){
  266. /*IF*/if (((C)->_capacity)<((rT230count(C))+(1))) {
  267. C->_capacity=((C)->_capacity)+(16);
  268. /*IF*/if (((C)->_capacity)==(16)) {
  269. C->_storage=malloc(16*sizeof(*(C->_storage)));
  270. }
  271. else {
  272. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  273. }
  274. /*FI*/}
  275. /*FI*/C->_upper=((C)->_upper)+(1);
  276. rT230put(C,a1,(C)->_upper);
  277. }
  278. void rT230put(T230 *C,T0 * a1,int a2){
  279. (C->_storage)[a2-(C->_lower)]=a1;
  280. }
  281. void rT230copy(T230 *C,T0* a1){
  282. int _i=0;
  283. C->_upper=((C)->_lower)-(1);
  284. /*IF*/if (((C)->_capacity)==(0)) {
  285. rT230make(C,((T230*)a1)->_lower,((T230*)a1)->_upper);
  286. }
  287. else {
  288. rT230resize(C,((T230*)a1)->_lower,((T230*)a1)->_upper);
  289. }
  290. /*FI*/_i=(C)->_lower;
  291. while (!((_i)>((C)->_upper))) {
  292. rT230put(C,rT230item((T230*)a1,_i),_i);
  293. _i=(_i)+(1);
  294. }
  295. }
  296. void rT230make(T230 *C,int a1,int a2){
  297. /*IF*/{/*AT*/free(C->_storage);
  298. }
  299. /*FI*/C->_lower=a1;
  300. C->_upper=a2;
  301. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  302. C->_storage=NULL;
  303. /*IF*/if (((C)->_capacity)>(0)) {
  304. C->_capacity=((C)->_capacity)+(16);
  305. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  306. rT230clear_all(C);
  307. }
  308. /*FI*/}
  309. void rT227clear_all(T227 *C){
  310. T0 * _value=NULL;
  311. rT227set_all_with(C,_value);
  312. }
  313. int rT227count(T227 *C){
  314. int R=0;
  315. R=(((C)->_upper)-((C)->_lower))+(1);
  316. return R;
  317. }
  318. void rT227set_all_with(T227 *C,T0 * a1){
  319. int _i=0;
  320. _i=(C)->_upper;
  321. while (!((_i)<((C)->_lower))) {
  322. rT227put(C,a1,_i);
  323. _i=(_i)-(1);
  324. }
  325. }
  326. void rT227resize(T227 *C,int a1,int a2){
  327. int _up=0;
  328. int _i=0;
  329. T0* _other=NULL;
  330. {T227 *n=((T227*)new(227));
  331. rT227make(n,a1,a2);
  332. _other=(T0 *)n;}
  333. _i=rT2max((C)->_lower,((T227*)_other)->_lower);
  334. _up=rT2min((C)->_upper,((T227*)_other)->_upper);
  335. while (!((_i)>(_up))) {
  336. rT227put((T227*)_other,rT227item(C,_i),_i);
  337. _i=(_i)+(1);
  338. }
  339. /*IF*/{/*AT*/free(C->_storage);
  340. }
  341. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  342. }
  343. T0 * rT227item(T227 *C,int a1){
  344. T0 * R=NULL;
  345. R=(C->_storage)[a1-(C->_lower)];
  346. return R;
  347. }
  348. void rT227add_last(T227 *C,T0 * a1){
  349. /*IF*/if (((C)->_capacity)<((rT227count(C))+(1))) {
  350. C->_capacity=((C)->_capacity)+(16);
  351. /*IF*/if (((C)->_capacity)==(16)) {
  352. C->_storage=malloc(16*sizeof(*(C->_storage)));
  353. }
  354. else {
  355. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  356. }
  357. /*FI*/}
  358. /*FI*/C->_upper=((C)->_upper)+(1);
  359. rT227put(C,a1,(C)->_upper);
  360. }
  361. void rT227put(T227 *C,T0 * a1,int a2){
  362. (C->_storage)[a2-(C->_lower)]=a1;
  363. }
  364. void rT227copy(T227 *C,T0* a1){
  365. int _i=0;
  366. C->_upper=((C)->_lower)-(1);
  367. /*IF*/if (((C)->_capacity)==(0)) {
  368. rT227make(C,((T227*)a1)->_lower,((T227*)a1)->_upper);
  369. }
  370. else {
  371. rT227resize(C,((T227*)a1)->_lower,((T227*)a1)->_upper);
  372. }
  373. /*FI*/_i=(C)->_lower;
  374. while (!((_i)>((C)->_upper))) {
  375. rT227put(C,rT227item((T227*)a1,_i),_i);
  376. _i=(_i)+(1);
  377. }
  378. }
  379. void rT227make(T227 *C,int a1,int a2){
  380. /*IF*/{/*AT*/free(C->_storage);
  381. }
  382. /*FI*/C->_lower=a1;
  383. C->_upper=a2;
  384. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  385. C->_storage=NULL;
  386. /*IF*/if (((C)->_capacity)>(0)) {
  387. C->_capacity=((C)->_capacity)+(16);
  388. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  389. rT227clear_all(C);
  390. }
  391. /*FI*/}
  392. void rT221clear_all(T221 *C){
  393. T0 * _value=NULL;
  394. rT221set_all_with(C,_value);
  395. }
  396. int rT221count(T221 *C){
  397. int R=0;
  398. R=(((C)->_upper)-((C)->_lower))+(1);
  399. return R;
  400. }
  401. void rT221set_all_with(T221 *C,T0 * a1){
  402. int _i=0;
  403. _i=(C)->_upper;
  404. while (!((_i)<((C)->_lower))) {
  405. rT221put(C,a1,_i);
  406. _i=(_i)-(1);
  407. }
  408. }
  409. void rT221resize(T221 *C,int a1,int a2){
  410. int _up=0;
  411. int _i=0;
  412. T0* _other=NULL;
  413. {T221 *n=((T221*)new(221));
  414. rT221make(n,a1,a2);
  415. _other=(T0 *)n;}
  416. _i=rT2max((C)->_lower,((T221*)_other)->_lower);
  417. _up=rT2min((C)->_upper,((T221*)_other)->_upper);
  418. while (!((_i)>(_up))) {
  419. rT221put((T221*)_other,rT221item(C,_i),_i);
  420. _i=(_i)+(1);
  421. }
  422. /*IF*/{/*AT*/free(C->_storage);
  423. }
  424. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  425. }
  426. T0 * rT221item(T221 *C,int a1){
  427. T0 * R=NULL;
  428. R=(C->_storage)[a1-(C->_lower)];
  429. return R;
  430. }
  431. void rT221add_last(T221 *C,T0 * a1){
  432. /*IF*/if (((C)->_capacity)<((rT221count(C))+(1))) {
  433. C->_capacity=((C)->_capacity)+(16);
  434. /*IF*/if (((C)->_capacity)==(16)) {
  435. C->_storage=malloc(16*sizeof(*(C->_storage)));
  436. }
  437. else {
  438. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  439. }
  440. /*FI*/}
  441. /*FI*/C->_upper=((C)->_upper)+(1);
  442. rT221put(C,a1,(C)->_upper);
  443. }
  444. void rT221put(T221 *C,T0 * a1,int a2){
  445. (C->_storage)[a2-(C->_lower)]=a1;
  446. }
  447. void rT221copy(T221 *C,T0* a1){
  448. int _i=0;
  449. C->_upper=((C)->_lower)-(1);
  450. /*IF*/if (((C)->_capacity)==(0)) {
  451. rT221make(C,((T221*)a1)->_lower,((T221*)a1)->_upper);
  452. }
  453. else {
  454. rT221resize(C,((T221*)a1)->_lower,((T221*)a1)->_upper);
  455. }
  456. /*FI*/_i=(C)->_lower;
  457. while (!((_i)>((C)->_upper))) {
  458. rT221put(C,rT221item((T221*)a1,_i),_i);
  459. _i=(_i)+(1);
  460. }
  461. }
  462. void rT221make(T221 *C,int a1,int a2){
  463. /*IF*/{/*AT*/free(C->_storage);
  464. }
  465. /*FI*/C->_lower=a1;
  466. C->_upper=a2;
  467. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  468. C->_storage=NULL;
  469. /*IF*/if (((C)->_capacity)>(0)) {
  470. C->_capacity=((C)->_capacity)+(16);
  471. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  472. rT221clear_all(C);
  473. }
  474. /*FI*/}
  475. void rT215clear_all(T215 *C){
  476. T0 * _value=NULL;
  477. rT215set_all_with(C,_value);
  478. }
  479. int rT215count(T215 *C){
  480. int R=0;
  481. R=(((C)->_upper)-((C)->_lower))+(1);
  482. return R;
  483. }
  484. void rT215set_all_with(T215 *C,T0 * a1){
  485. int _i=0;
  486. _i=(C)->_upper;
  487. while (!((_i)<((C)->_lower))) {
  488. rT215put(C,a1,_i);
  489. _i=(_i)-(1);
  490. }
  491. }
  492. void rT215resize(T215 *C,int a1,int a2){
  493. int _up=0;
  494. int _i=0;
  495. T0* _other=NULL;
  496. {T215 *n=((T215*)new(215));
  497. rT215make(n,a1,a2);
  498. _other=(T0 *)n;}
  499. _i=rT2max((C)->_lower,((T215*)_other)->_lower);
  500. _up=rT2min((C)->_upper,((T215*)_other)->_upper);
  501. while (!((_i)>(_up))) {
  502. rT215put((T215*)_other,rT215item(C,_i),_i);
  503. _i=(_i)+(1);
  504. }
  505. /*IF*/{/*AT*/free(C->_storage);
  506. }
  507. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  508. }
  509. T0 * rT215item(T215 *C,int a1){
  510. T0 * R=NULL;
  511. R=(C->_storage)[a1-(C->_lower)];
  512. return R;
  513. }
  514. void rT215add_last(T215 *C,T0 * a1){
  515. /*IF*/if (((C)->_capacity)<((rT215count(C))+(1))) {
  516. C->_capacity=((C)->_capacity)+(16);
  517. /*IF*/if (((C)->_capacity)==(16)) {
  518. C->_storage=malloc(16*sizeof(*(C->_storage)));
  519. }
  520. else {
  521. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  522. }
  523. /*FI*/}
  524. /*FI*/C->_upper=((C)->_upper)+(1);
  525. rT215put(C,a1,(C)->_upper);
  526. }
  527. void rT215put(T215 *C,T0 * a1,int a2){
  528. (C->_storage)[a2-(C->_lower)]=a1;
  529. }
  530. void rT215copy(T215 *C,T0* a1){
  531. int _i=0;
  532. C->_upper=((C)->_lower)-(1);
  533. /*IF*/if (((C)->_capacity)==(0)) {
  534. rT215make(C,((T215*)a1)->_lower,((T215*)a1)->_upper);
  535. }
  536. else {
  537. rT215resize(C,((T215*)a1)->_lower,((T215*)a1)->_upper);
  538. }
  539. /*FI*/_i=(C)->_lower;
  540. while (!((_i)>((C)->_upper))) {
  541. rT215put(C,rT215item((T215*)a1,_i),_i);
  542. _i=(_i)+(1);
  543. }
  544. }
  545. void rT215make(T215 *C,int a1,int a2){
  546. /*IF*/{/*AT*/free(C->_storage);
  547. }
  548. /*FI*/C->_lower=a1;
  549. C->_upper=a2;
  550. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  551. C->_storage=NULL;
  552. /*IF*/if (((C)->_capacity)>(0)) {
  553. C->_capacity=((C)->_capacity)+(16);
  554. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  555. rT215clear_all(C);
  556. }
  557. /*FI*/}
  558. void rT94clear_all(T94 *C){
  559. T0 * _value=NULL;
  560. rT94set_all_with(C,_value);
  561. }
  562. T0 * rT94first(T94 *C){
  563. T0 * R=NULL;
  564. R=rT94item(C,(C)->_lower);
  565. return R;
  566. }
  567. int rT94count(T94 *C){
  568. int R=0;
  569. R=(((C)->_upper)-((C)->_lower))+(1);
  570. return R;
  571. }
  572. void rT94set_all_with(T94 *C,T0 * a1){
  573. int _i=0;
  574. _i=(C)->_upper;
  575. while (!((_i)<((C)->_lower))) {
  576. rT94put(C,a1,_i);
  577. _i=(_i)-(1);
  578. }
  579. }
  580. void rT94resize(T94 *C,int a1,int a2){
  581. int _up=0;
  582. int _i=0;
  583. T0* _other=NULL;
  584. {T94 *n=((T94*)new(94));
  585. rT94make(n,a1,a2);
  586. _other=(T0 *)n;}
  587. _i=rT2max((C)->_lower,((T94*)_other)->_lower);
  588. _up=rT2min((C)->_upper,((T94*)_other)->_upper);
  589. while (!((_i)>(_up))) {
  590. rT94put((T94*)_other,rT94item(C,_i),_i);
  591. _i=(_i)+(1);
  592. }
  593. /*IF*/{/*AT*/free(C->_storage);
  594. }
  595. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  596. }
  597. T0 * rT94item(T94 *C,int a1){
  598. T0 * R=NULL;
  599. R=(C->_storage)[a1-(C->_lower)];
  600. return R;
  601. }
  602. void rT94add_last(T94 *C,T0 * a1){
  603. /*IF*/if (((C)->_capacity)<((rT94count(C))+(1))) {
  604. C->_capacity=((C)->_capacity)+(16);
  605. /*IF*/if (((C)->_capacity)==(16)) {
  606. C->_storage=malloc(16*sizeof(*(C->_storage)));
  607. }
  608. else {
  609. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  610. }
  611. /*FI*/}
  612. /*FI*/C->_upper=((C)->_upper)+(1);
  613. rT94put(C,a1,(C)->_upper);
  614. }
  615. int rT94equal_like(/*C*/T0 * a1,T0 * a2){
  616. int R=0;
  617. /*IF*//*AF*/if (((T0 *)a1)==((T0 *)a2)) {
  618. R=1;
  619. }
  620.  else if ((!(a1))||(!(a2))) {
  621. }
  622. else {
  623. R=rT92is_equal((T92*)a1,a2);
  624. }
  625. /*FI*/return R;
  626. }
  627. int rT94index_of(T94 *C,T0 * a1){
  628. int R=0;
  629. R=(C)->_lower;
  630. while (!(((R)>((C)->_upper))||(rT94equal_like(a1,rT94item(C,R))))) {
  631. R=(R)+(1);
  632. }
  633. return R;
  634. }
  635. void rT94put(T94 *C,T0 * a1,int a2){
  636. (C->_storage)[a2-(C->_lower)]=a1;
  637. }
  638. void rT94copy(T94 *C,T0* a1){
  639. int _i=0;
  640. C->_upper=((C)->_lower)-(1);
  641. /*IF*/if (((C)->_capacity)==(0)) {
  642. rT94make(C,((T94*)a1)->_lower,((T94*)a1)->_upper);
  643. }
  644. else {
  645. rT94resize(C,((T94*)a1)->_lower,((T94*)a1)->_upper);
  646. }
  647. /*FI*/_i=(C)->_lower;
  648. while (!((_i)>((C)->_upper))) {
  649. rT94put(C,rT94item((T94*)a1,_i),_i);
  650. _i=(_i)+(1);
  651. }
  652. }
  653. void rT94make(T94 *C,int a1,int a2){
  654. /*IF*/{/*AT*/free(C->_storage);
  655. }
  656. /*FI*/C->_lower=a1;
  657. C->_upper=a2;
  658. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  659. C->_storage=NULL;
  660. /*IF*/if (((C)->_capacity)>(0)) {
  661. C->_capacity=((C)->_capacity)+(16);
  662. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  663. rT94clear_all(C);
  664. }
  665. /*FI*/}
  666. void rT84clear_all(T84 *C){
  667. T0 * _value=NULL;
  668. rT84set_all_with(C,_value);
  669. }
  670. int rT84count(T84 *C){
  671. int R=0;
  672. R=(((C)->_upper)-((C)->_lower))+(1);
  673. return R;
  674. }
  675. void rT84set_all_with(T84 *C,T0 * a1){
  676. int _i=0;
  677. _i=(C)->_upper;
  678. while (!((_i)<((C)->_lower))) {
  679. rT84put(C,a1,_i);
  680. _i=(_i)-(1);
  681. }
  682. }
  683. void rT84resize(T84 *C,int a1,int a2){
  684. int _up=0;
  685. int _i=0;
  686. T0* _other=NULL;
  687. {T84 *n=((T84*)new(84));
  688. rT84make(n,a1,a2);
  689. _other=(T0 *)n;}
  690. _i=rT2max((C)->_lower,((T84*)_other)->_lower);
  691. _up=rT2min((C)->_upper,((T84*)_other)->_upper);
  692. while (!((_i)>(_up))) {
  693. rT84put((T84*)_other,rT84item(C,_i),_i);
  694. _i=(_i)+(1);
  695. }
  696. /*IF*/{/*AT*/free(C->_storage);
  697. }
  698. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  699. }
  700. T0 * rT84item(T84 *C,int a1){
  701. T0 * R=NULL;
  702. R=(C->_storage)[a1-(C->_lower)];
  703. return R;
  704. }
  705. void rT84add_last(T84 *C,T0 * a1){
  706. /*IF*/if (((C)->_capacity)<((rT84count(C))+(1))) {
  707. C->_capacity=((C)->_capacity)+(16);
  708. /*IF*/if (((C)->_capacity)==(16)) {
  709. C->_storage=malloc(16*sizeof(*(C->_storage)));
  710. }
  711. else {
  712. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  713. }
  714. /*FI*/}
  715. /*FI*/C->_upper=((C)->_upper)+(1);
  716. rT84put(C,a1,(C)->_upper);
  717. }
  718. void rT84put(T84 *C,T0 * a1,int a2){
  719. (C->_storage)[a2-(C->_lower)]=a1;
  720. }
  721. void rT84copy(T84 *C,T0* a1){
  722. int _i=0;
  723. C->_upper=((C)->_lower)-(1);
  724. /*IF*/if (((C)->_capacity)==(0)) {
  725. rT84make(C,((T84*)a1)->_lower,((T84*)a1)->_upper);
  726. }
  727. else {
  728. rT84resize(C,((T84*)a1)->_lower,((T84*)a1)->_upper);
  729. }
  730. /*FI*/_i=(C)->_lower;
  731. while (!((_i)>((C)->_upper))) {
  732. rT84put(C,rT84item((T84*)a1,_i),_i);
  733. _i=(_i)+(1);
  734. }
  735. }
  736. void rT84make(T84 *C,int a1,int a2){
  737. /*IF*/{/*AT*/free(C->_storage);
  738. }
  739. /*FI*/C->_lower=a1;
  740. C->_upper=a2;
  741. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  742. C->_storage=NULL;
  743. /*IF*/if (((C)->_capacity)>(0)) {
  744. C->_capacity=((C)->_capacity)+(16);
  745. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  746. rT84clear_all(C);
  747. }
  748. /*FI*/}
  749. void rT81clear_all(T81 *C){
  750. T0 * _value=NULL;
  751. rT81set_all_with(C,_value);
  752. }
  753. int rT81count(T81 *C){
  754. int R=0;
  755. R=(((C)->_upper)-((C)->_lower))+(1);
  756. return R;
  757. }
  758. void rT81set_all_with(T81 *C,T0 * a1){
  759. int _i=0;
  760. _i=(C)->_upper;
  761. while (!((_i)<((C)->_lower))) {
  762. rT81put(C,a1,_i);
  763. _i=(_i)-(1);
  764. }
  765. }
  766. void rT81resize(T81 *C,int a1,int a2){
  767. int _up=0;
  768. int _i=0;
  769. T0* _other=NULL;
  770. {T81 *n=((T81*)new(81));
  771. rT81make(n,a1,a2);
  772. _other=(T0 *)n;}
  773. _i=rT2max((C)->_lower,((T81*)_other)->_lower);
  774. _up=rT2min((C)->_upper,((T81*)_other)->_upper);
  775. while (!((_i)>(_up))) {
  776. rT81put((T81*)_other,rT81item(C,_i),_i);
  777. _i=(_i)+(1);
  778. }
  779. /*IF*/{/*AT*/free(C->_storage);
  780. }
  781. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  782. }
  783. T0 * rT81item(T81 *C,int a1){
  784. T0 * R=NULL;
  785. R=(C->_storage)[a1-(C->_lower)];
  786. return R;
  787. }
  788. void rT81add_last(T81 *C,T0 * a1){
  789. /*IF*/if (((C)->_capacity)<((rT81count(C))+(1))) {
  790. C->_capacity=((C)->_capacity)+(16);
  791. /*IF*/if (((C)->_capacity)==(16)) {
  792. C->_storage=malloc(16*sizeof(*(C->_storage)));
  793. }
  794. else {
  795. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  796. }
  797. /*FI*/}
  798. /*FI*/C->_upper=((C)->_upper)+(1);
  799. rT81put(C,a1,(C)->_upper);
  800. }
  801. void rT81put(T81 *C,T0 * a1,int a2){
  802. (C->_storage)[a2-(C->_lower)]=a1;
  803. }
  804. void rT81copy(T81 *C,T0* a1){
  805. int _i=0;
  806. C->_upper=((C)->_lower)-(1);
  807. /*IF*/if (((C)->_capacity)==(0)) {
  808. rT81make(C,((T81*)a1)->_lower,((T81*)a1)->_upper);
  809. }
  810. else {
  811. rT81resize(C,((T81*)a1)->_lower,((T81*)a1)->_upper);
  812. }
  813. /*FI*/_i=(C)->_lower;
  814. while (!((_i)>((C)->_upper))) {
  815. rT81put(C,rT81item((T81*)a1,_i),_i);
  816. _i=(_i)+(1);
  817. }
  818. }
  819. void rT81make(T81 *C,int a1,int a2){
  820. /*IF*/{/*AT*/free(C->_storage);
  821. }
  822. /*FI*/C->_lower=a1;
  823. C->_upper=a2;
  824. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  825. C->_storage=NULL;
  826. /*IF*/if (((C)->_capacity)>(0)) {
  827. C->_capacity=((C)->_capacity)+(16);
  828. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  829. rT81clear_all(C);
  830. }
  831. /*FI*/}
  832. void rT79clear_all(T79 *C){
  833. T0 * _value=NULL;
  834. rT79set_all_with(C,_value);
  835. }
  836. int rT79count(T79 *C){
  837. int R=0;
  838. R=(((C)->_upper)-((C)->_lower))+(1);
  839. return R;
  840. }
  841. void rT79set_all_with(T79 *C,T0 * a1){
  842. int _i=0;
  843. _i=(C)->_upper;
  844. while (!((_i)<((C)->_lower))) {
  845. rT79put(C,a1,_i);
  846. _i=(_i)-(1);
  847. }
  848. }
  849. void rT79resize(T79 *C,int a1,int a2){
  850. int _up=0;
  851. int _i=0;
  852. T0* _other=NULL;
  853. {T79 *n=((T79*)new(79));
  854. rT79make(n,a1,a2);
  855. _other=(T0 *)n;}
  856. _i=rT2max((C)->_lower,XrT79lower(_other));
  857. _up=rT2min((C)->_upper,XrT79upper(_other));
  858. while (!((_i)>(_up))) {
  859. XrT79put(_other,rT79item(C,_i),_i);
  860. _i=(_i)+(1);
  861. }
  862. /*IF*/{/*AT*/free(C->_storage);
  863. }
  864. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  865. }
  866. T0 * rT79item(T79 *C,int a1){
  867. T0 * R=NULL;
  868. R=(C->_storage)[a1-(C->_lower)];
  869. return R;
  870. }
  871. void rT79add_last(T79 *C,T0 * a1){
  872. /*IF*/if (((C)->_capacity)<((rT79count(C))+(1))) {
  873. C->_capacity=((C)->_capacity)+(16);
  874. /*IF*/if (((C)->_capacity)==(16)) {
  875. C->_storage=malloc(16*sizeof(*(C->_storage)));
  876. }
  877. else {
  878. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  879. }
  880. /*FI*/}
  881. /*FI*/C->_upper=((C)->_upper)+(1);
  882. rT79put(C,a1,(C)->_upper);
  883. }
  884. void rT79put(T79 *C,T0 * a1,int a2){
  885. (C->_storage)[a2-(C->_lower)]=a1;
  886. }
  887. void rT79copy(T79 *C,T0* a1){
  888. int _i=0;
  889. C->_upper=((C)->_lower)-(1);
  890. /*IF*/if (((C)->_capacity)==(0)) {
  891. rT79make(C,XrT79lower(a1),XrT79upper(a1));
  892. }
  893. else {
  894. rT79resize(C,XrT79lower(a1),XrT79upper(a1));
  895. }
  896. /*FI*/_i=(C)->_lower;
  897. while (!((_i)>((C)->_upper))) {
  898. rT79put(C,XrT79item(a1,_i),_i);
  899. _i=(_i)+(1);
  900. }
  901. }
  902. void rT79make(T79 *C,int a1,int a2){
  903. /*IF*/{/*AT*/free(C->_storage);
  904. }
  905. /*FI*/C->_lower=a1;
  906. C->_upper=a2;
  907. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  908. C->_storage=NULL;
  909. /*IF*/if (((C)->_capacity)>(0)) {
  910. C->_capacity=((C)->_capacity)+(16);
  911. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  912. rT79clear_all(C);
  913. }
  914. /*FI*/}
  915. void rT61clear_all(T61 *C){
  916. T0 * _value=NULL;
  917. rT61set_all_with(C,_value);
  918. }
  919. int rT61count(T61 *C){
  920. int R=0;
  921. R=(((C)->_upper)-((C)->_lower))+(1);
  922. return R;
  923. }
  924. void rT61set_all_with(T61 *C,T0 * a1){
  925. int _i=0;
  926. _i=(C)->_upper;
  927. while (!((_i)<((C)->_lower))) {
  928. rT61put(C,a1,_i);
  929. _i=(_i)-(1);
  930. }
  931. }
  932. void rT61resize(T61 *C,int a1,int a2){
  933. int _up=0;
  934. int _i=0;
  935. T0* _other=NULL;
  936. {T61 *n=((T61*)new(61));
  937. rT61make(n,a1,a2);
  938. _other=(T0 *)n;}
  939. _i=rT2max((C)->_lower,((T61*)_other)->_lower);
  940. _up=rT2min((C)->_upper,((T61*)_other)->_upper);
  941. while (!((_i)>(_up))) {
  942. rT61put((T61*)_other,rT61item(C,_i),_i);
  943. _i=(_i)+(1);
  944. }
  945. /*IF*/{/*AT*/free(C->_storage);
  946. }
  947. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  948. }
  949. T0 * rT61item(T61 *C,int a1){
  950. T0 * R=NULL;
  951. R=(C->_storage)[a1-(C->_lower)];
  952. return R;
  953. }
  954. int rT61empty(T61 *C){
  955. int R=0;
  956. R=(rT61count(C))==(0);
  957. return R;
  958. }
  959. void rT61add_last(T61 *C,T0 * a1){
  960. /*IF*/if (((C)->_capacity)<((rT61count(C))+(1))) {
  961. C->_capacity=((C)->_capacity)+(16);
  962. /*IF*/if (((C)->_capacity)==(16)) {
  963. C->_storage=malloc(16*sizeof(*(C->_storage)));
  964. }
  965. else {
  966. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  967. }
  968. /*FI*/}
  969. /*FI*/C->_upper=((C)->_upper)+(1);
  970. rT61put(C,a1,(C)->_upper);
  971. }
  972. void rT61put(T61 *C,T0 * a1,int a2){
  973. (C->_storage)[a2-(C->_lower)]=a1;
  974. }
  975. void rT61copy(T61 *C,T0* a1){
  976. int _i=0;
  977. C->_upper=((C)->_lower)-(1);
  978. /*IF*/if (((C)->_capacity)==(0)) {
  979. rT61make(C,((T61*)a1)->_lower,((T61*)a1)->_upper);
  980. }
  981. else {
  982. rT61resize(C,((T61*)a1)->_lower,((T61*)a1)->_upper);
  983. }
  984. /*FI*/_i=(C)->_lower;
  985. while (!((_i)>((C)->_upper))) {
  986. rT61put(C,rT61item((T61*)a1,_i),_i);
  987. _i=(_i)+(1);
  988. }
  989. }
  990. void rT61make(T61 *C,int a1,int a2){
  991. /*IF*/{/*AT*/free(C->_storage);
  992. }
  993. /*FI*/C->_lower=a1;
  994. C->_upper=a2;
  995. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  996. C->_storage=NULL;
  997. /*IF*/if (((C)->_capacity)>(0)) {
  998. C->_capacity=((C)->_capacity)+(16);
  999. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  1000. rT61clear_all(C);
  1001. }
  1002. /*FI*/}
  1003. void rT54clear_all(T54 *C){
  1004. T0 * _value=NULL;
  1005. rT54set_all_with(C,_value);
  1006. }
  1007. int rT54count(T54 *C){
  1008. int R=0;
  1009. R=(((C)->_upper)-((C)->_lower))+(1);
  1010. return R;
  1011. }
  1012. void rT54set_all_with(T54 *C,T0 * a1){
  1013. int _i=0;
  1014. _i=(C)->_upper;
  1015. while (!((_i)<((C)->_lower))) {
  1016. rT54put(C,a1,_i);
  1017. _i=(_i)-(1);
  1018. }
  1019. }
  1020. void rT54resize(T54 *C,int a1,int a2){
  1021. int _up=0;
  1022. int _i=0;
  1023. T0* _other=NULL;
  1024. {T54 *n=((T54*)new(54));
  1025. rT54make(n,a1,a2);
  1026. _other=(T0 *)n;}
  1027. _i=rT2max((C)->_lower,((T54*)_other)->_lower);
  1028. _up=rT2min((C)->_upper,((T54*)_other)->_upper);
  1029. while (!((_i)>(_up))) {
  1030. rT54put((T54*)_other,rT54item(C,_i),_i);
  1031. _i=(_i)+(1);
  1032. }
  1033. /*IF*/{/*AT*/free(C->_storage);
  1034. }
  1035. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  1036. }
  1037. T0 * rT54item(T54 *C,int a1){
  1038. T0 * R=NULL;
  1039. R=(C->_storage)[a1-(C->_lower)];
  1040. return R;
  1041. }
  1042. void rT54put(T54 *C,T0 * a1,int a2){
  1043. (C->_storage)[a2-(C->_lower)]=a1;
  1044. }
  1045. void rT54copy(T54 *C,T0* a1){
  1046. int _i=0;
  1047. C->_upper=((C)->_lower)-(1);
  1048. /*IF*/if (((C)->_capacity)==(0)) {
  1049. rT54make(C,((T54*)a1)->_lower,((T54*)a1)->_upper);
  1050. }
  1051. else {
  1052. rT54resize(C,((T54*)a1)->_lower,((T54*)a1)->_upper);
  1053. }
  1054. /*FI*/_i=(C)->_lower;
  1055. while (!((_i)>((C)->_upper))) {
  1056. rT54put(C,rT54item((T54*)a1,_i),_i);
  1057. _i=(_i)+(1);
  1058. }
  1059. }
  1060. void rT54make(T54 *C,int a1,int a2){
  1061. /*IF*/{/*AT*/free(C->_storage);
  1062. }
  1063. /*FI*/C->_lower=a1;
  1064. C->_upper=a2;
  1065. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  1066. C->_storage=NULL;
  1067. /*IF*/if (((C)->_capacity)>(0)) {
  1068. C->_capacity=((C)->_capacity)+(16);
  1069. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  1070. rT54clear_all(C);
  1071. }
  1072. /*FI*/}
  1073. void rT53clear_all(T53 *C){
  1074. int _value=0;
  1075. rT53set_all_with(C,_value);
  1076. }
  1077. int rT53count(T53 *C){
  1078. int R=0;
  1079. R=(((C)->_upper)-((C)->_lower))+(1);
  1080. return R;
  1081. }
  1082. void rT53set_all_with(T53 *C,int a1){
  1083. int _i=0;
  1084. _i=(C)->_upper;
  1085. while (!((_i)<((C)->_lower))) {
  1086. rT53put(C,a1,_i);
  1087. _i=(_i)-(1);
  1088. }
  1089. }
  1090. int rT53fast_index_of(T53 *C,int a1){
  1091. int R=0;
  1092. R=(C)->_lower;
  1093. while (!(((R)>((C)->_upper))||((a1)==(rT53item(C,R))))) {
  1094. R=(R)+(1);
  1095. }
  1096. return R;
  1097. }
  1098. int rT53fast_has(T53 *C,int a1){
  1099. int R=0;
  1100. R=(rT53fast_index_of(C,a1))!=(((C)->_upper)+(1));
  1101. return R;
  1102. }
  1103. void rT53resize(T53 *C,int a1,int a2){
  1104. int _up=0;
  1105. int _i=0;
  1106. T0* _other=NULL;
  1107. {T53 *n=((T53*)new(53));
  1108. rT53make(n,a1,a2);
  1109. _other=(T0 *)n;}
  1110. _i=rT2max((C)->_lower,((T53*)_other)->_lower);
  1111. _up=rT2min((C)->_upper,((T53*)_other)->_upper);
  1112. while (!((_i)>(_up))) {
  1113. rT53put((T53*)_other,rT53item(C,_i),_i);
  1114. _i=(_i)+(1);
  1115. }
  1116. /*IF*/{/*AT*/free(C->_storage);
  1117. }
  1118. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  1119. }
  1120. int rT53item(T53 *C,int a1){
  1121. int R=0;
  1122. R=(C->_storage)[a1-(C->_lower)];
  1123. return R;
  1124. }
  1125. void rT53add_last(T53 *C,int a1){
  1126. /*IF*/if (((C)->_capacity)<((rT53count(C))+(1))) {
  1127. C->_capacity=((C)->_capacity)+(16);
  1128. /*IF*/if (((C)->_capacity)==(16)) {
  1129. C->_storage=malloc(16*sizeof(*(C->_storage)));
  1130. }
  1131. else {
  1132. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  1133. }
  1134. /*FI*/}
  1135. /*FI*/C->_upper=((C)->_upper)+(1);
  1136. rT53put(C,a1,(C)->_upper);
  1137. }
  1138. void rT53put(T53 *C,int a1,int a2){
  1139. (C->_storage)[a2-(C->_lower)]=a1;
  1140. }
  1141. void rT53copy(T53 *C,T0* a1){
  1142. int _i=0;
  1143. C->_upper=((C)->_lower)-(1);
  1144. /*IF*/if (((C)->_capacity)==(0)) {
  1145. rT53make(C,((T53*)a1)->_lower,((T53*)a1)->_upper);
  1146. }
  1147. else {
  1148. rT53resize(C,((T53*)a1)->_lower,((T53*)a1)->_upper);
  1149. }
  1150. /*FI*/_i=(C)->_lower;
  1151. while (!((_i)>((C)->_upper))) {
  1152. rT53put(C,rT53item((T53*)a1,_i),_i);
  1153. _i=(_i)+(1);
  1154. }
  1155. }
  1156. void rT53make(T53 *C,int a1,int a2){
  1157. /*IF*/{/*AT*/free(C->_storage);
  1158. }
  1159. /*FI*/C->_lower=a1;
  1160. C->_upper=a2;
  1161. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  1162. C->_storage=NULL;
  1163. /*IF*/if (((C)->_capacity)>(0)) {
  1164. C->_capacity=((C)->_capacity)+(16);
  1165. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  1166. rT53clear_all(C);
  1167. }
  1168. /*FI*/}
  1169. void rT45clear(T45 *C){
  1170. C->_upper=((C)->_lower)-(1);
  1171. }
  1172. void rT45clear_all(T45 *C){
  1173. T0 * _value=NULL;
  1174. rT45set_all_with(C,_value);
  1175. }
  1176. int rT45count(T45 *C){
  1177. int R=0;
  1178. R=(((C)->_upper)-((C)->_lower))+(1);
  1179. return R;
  1180. }
  1181. void rT45set_all_with(T45 *C,T0 * a1){
  1182. int _i=0;
  1183. _i=(C)->_upper;
  1184. while (!((_i)<((C)->_lower))) {
  1185. rT45put(C,a1,_i);
  1186. _i=(_i)-(1);
  1187. }
  1188. }
  1189. void rT45resize(T45 *C,int a1,int a2){
  1190. int _up=0;
  1191. int _i=0;
  1192. T0* _other=NULL;
  1193. {T45 *n=((T45*)new(45));
  1194. rT45make(n,a1,a2);
  1195. _other=(T0 *)n;}
  1196. _i=rT2max((C)->_lower,((T45*)_other)->_lower);
  1197. _up=rT2min((C)->_upper,((T45*)_other)->_upper);
  1198. while (!((_i)>(_up))) {
  1199. rT45put((T45*)_other,rT45item(C,_i),_i);
  1200. _i=(_i)+(1);
  1201. }
  1202. /*IF*/{/*AT*/free(C->_storage);
  1203. }
  1204. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  1205. }
  1206. T0 * rT45item(T45 *C,int a1){
  1207. T0 * R=NULL;
  1208. R=(C->_storage)[a1-(C->_lower)];
  1209. return R;
  1210. }
  1211. void rT45add_last(T45 *C,T0 * a1){
  1212. /*IF*/if (((C)->_capacity)<((rT45count(C))+(1))) {
  1213. C->_capacity=((C)->_capacity)+(16);
  1214. /*IF*/if (((C)->_capacity)==(16)) {
  1215. C->_storage=malloc(16*sizeof(*(C->_storage)));
  1216. }
  1217. else {
  1218. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  1219. }
  1220. /*FI*/}
  1221. /*FI*/C->_upper=((C)->_upper)+(1);
  1222. rT45put(C,a1,(C)->_upper);
  1223. }
  1224. int rT45equal_like(/*C*/T0 * a1,T0 * a2){
  1225. int R=0;
  1226. /*IF*//*AF*/if (((T0 *)a1)==((T0 *)a2)) {
  1227. R=1;
  1228. }
  1229.  else if ((!(a1))||(!(a2))) {
  1230. }
  1231. else {
  1232. R=rT44is_equal((T44*)a1,a2);
  1233. }
  1234. /*FI*/return R;
  1235. }
  1236. int rT45index_of(T45 *C,T0 * a1){
  1237. int R=0;
  1238. R=(C)->_lower;
  1239. while (!(((R)>((C)->_upper))||(rT45equal_like(a1,rT45item(C,R))))) {
  1240. R=(R)+(1);
  1241. }
  1242. return R;
  1243. }
  1244. void rT45put(T45 *C,T0 * a1,int a2){
  1245. (C->_storage)[a2-(C->_lower)]=a1;
  1246. }
  1247. void rT45copy(T45 *C,T0* a1){
  1248. int _i=0;
  1249. C->_upper=((C)->_lower)-(1);
  1250. /*IF*/if (((C)->_capacity)==(0)) {
  1251. rT45make(C,((T45*)a1)->_lower,((T45*)a1)->_upper);
  1252. }
  1253. else {
  1254. rT45resize(C,((T45*)a1)->_lower,((T45*)a1)->_upper);
  1255. }
  1256. /*FI*/_i=(C)->_lower;
  1257. while (!((_i)>((C)->_upper))) {
  1258. rT45put(C,rT45item((T45*)a1,_i),_i);
  1259. _i=(_i)+(1);
  1260. }
  1261. }
  1262. int rT45has(T45 *C,T0 * a1){
  1263. int R=0;
  1264. R=(rT45index_of(C,a1))!=(((C)->_upper)+(1));
  1265. return R;
  1266. }
  1267. void rT45make(T45 *C,int a1,int a2){
  1268. /*IF*/{/*AT*/free(C->_storage);
  1269. }
  1270. /*FI*/C->_lower=a1;
  1271. C->_upper=a2;
  1272. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  1273. C->_storage=NULL;
  1274. /*IF*/if (((C)->_capacity)>(0)) {
  1275. C->_capacity=((C)->_capacity)+(16);
  1276. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  1277. rT45clear_all(C);
  1278. }
  1279. /*FI*/}
  1280. void rT42clear(T42 *C){
  1281. C->_upper=((C)->_lower)-(1);
  1282. }
  1283. void rT42clear_all(T42 *C){
  1284. T0* _value=NULL;
  1285. rT42set_all_with(C,_value);
  1286. }
  1287. T0* rT42first(T42 *C){
  1288. T0* R=NULL;
  1289. R=rT42item(C,(C)->_lower);
  1290. return R;
  1291. }
  1292. int rT42count(T42 *C){
  1293. int R=0;
  1294. R=(((C)->_upper)-((C)->_lower))+(1);
  1295. return R;
  1296. }
  1297. void rT42set_all_with(T42 *C,T0* a1){
  1298. int _i=0;
  1299. _i=(C)->_upper;
  1300. while (!((_i)<((C)->_lower))) {
  1301. rT42put(C,a1,_i);
  1302. _i=(_i)-(1);
  1303. }
  1304. }
  1305. int rT42fast_index_of(T42 *C,T0* a1){
  1306. int R=0;
  1307. R=(C)->_lower;
  1308. while (!(((R)>((C)->_upper))||(((T0 *)a1)==((T0 *)rT42item(C,R))))) {
  1309. R=(R)+(1);
  1310. }
  1311. return R;
  1312. }
  1313. int rT42fast_has(T42 *C,T0* a1){
  1314. int R=0;
  1315. R=(rT42fast_index_of(C,a1))!=(((C)->_upper)+(1));
  1316. return R;
  1317. }
  1318. void rT42resize(T42 *C,int a1,int a2){
  1319. int _up=0;
  1320. int _i=0;
  1321. T0* _other=NULL;
  1322. {T42 *n=((T42*)new(42));
  1323. rT42make(n,a1,a2);
  1324. _other=(T0 *)n;}
  1325. _i=rT2max((C)->_lower,((T42*)_other)->_lower);
  1326. _up=rT2min((C)->_upper,((T42*)_other)->_upper);
  1327. while (!((_i)>(_up))) {
  1328. rT42put((T42*)_other,rT42item(C,_i),_i);
  1329. _i=(_i)+(1);
  1330. }
  1331. /*IF*/{/*AT*/free(C->_storage);
  1332. }
  1333. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  1334. }
  1335. int rT42empty(T42 *C){
  1336. int R=0;
  1337. R=(rT42count(C))==(0);
  1338. return R;
  1339. }
  1340. T0* rT42item(T42 *C,int a1){
  1341. T0* R=NULL;
  1342. R=(C->_storage)[a1-(C->_lower)];
  1343. return R;
  1344. }
  1345.